#include "creation.h"

int fin_crea, taille_carre_crea,decal_list_piece_2 = 0;
SDL_Surface * screen_crea, * b1c, * b2c, * backgroundc ;
SDL_Rect * pos_b1c, * pos_b2c, * pos_bgc ;
piece * piece_select_crea = NULL;
list_piece * pieces_reserve_crea, * pieces_jouees_crea;
list_carre * carre_plateau_vide_crea, * A_eclair_crea;

void reset_plateau()
{
    piece * plateau = pieces_jouees_crea->plateau , * tampon;
    list_carre * l_plateau = plateau->rotation1 ;
    carre * asup;
    while(plateau->suivant){
        tampon = plateau->suivant->suivant;
        supp_list_carre(plateau->suivant->rotation1);
        supp_list_carre(plateau->suivant->rotation2);
        supp_list_carre(plateau->suivant->rotation3);
        supp_list_carre(plateau->suivant->rotation4);
        supp_list_carre(plateau->suivant->rotation1i);
        supp_list_carre(plateau->suivant->rotation2i);
        supp_list_carre(plateau->suivant->rotation3i);
        supp_list_carre(plateau->suivant->rotation4i);
        free(plateau->suivant);
        plateau->suivant = tampon;
    }
    while(l_plateau->premier){
        asup = l_plateau->premier;
        l_plateau->premier = asup->suivant;
        free(asup);
    }
    l_plateau->hauteur = 0 ;
    l_plateau->largeur = 0 ;
}
int selection_carre_crea(int abscisse,int ordonner,int x, int y, list_carre * lc)
{
    int trouver = 0;
    carre * c = lc->premier;
    while(trouver == 0 && c){
        if( (x >= abscisse + c->abscisse * taille_carre_crea) && (x < abscisse + (c->abscisse + 1) * taille_carre_crea) ) {
            if( (y >= ordonner + c->ordonner * taille_carre_crea) && (y < ordonner + (c->ordonner + 1) * taille_carre_crea) ){
                trouver = 1;
            }
        }
        c = c->suivant;
    }
    return trouver;
}

void selection_creation(int x, int y, SDL_Surface * screen)
{
    if (x > A_BOUTON1 && x < A_BOUTON1 + L_BOUTON) {
        if (y > O_BOUTON1 && y < O_BOUTON1 + H_BOUTON) {
            if (decal_list_piece_2 < 1) {
                decal_list_piece_2 = pieces_reserve_crea->nb_piece - 2;
            } else {
                decal_list_piece_2 -= 1;
            }
            SDL_BlitSurface(b1c, NULL, screen, pos_b1c) ;
        }
    }
    if (x > A_BOUTON2 && x < A_BOUTON2 + L_BOUTON) {
        if (y > O_BOUTON2 && y < O_BOUTON2 + H_BOUTON) {
            if (decal_list_piece_2 >= pieces_reserve_crea->nb_piece - 2) {
                decal_list_piece_2 = 0;
            } else {
                decal_list_piece_2 += 1;
            }
            SDL_BlitSurface(b2c, NULL, screen, pos_b2c) ;
        }
    }
    if (x > A_BOUTONR1 && x < A_BOUTONR1 + L_BOUTON_ROND ) {
        if (y > O_BOUTONR1 && y < O_BOUTONR1 + H_BOUTON_ROND ) {
            reset_plateau() ;
        }
    }
    if (x > A_BOUTONR2 && x < A_BOUTONR2 + L_BOUTON_ROND ) {
        if (y > O_BOUTONR2 && y < O_BOUTONR2 + H_BOUTON_ROND ) {
            fin_crea = 1 ;
        }
    }
    int trouver = 0;
    piece * p = pieces_reserve_crea->plateau;
    while (p && trouver != 1) {
        trouver = selection_carre_crea(p->abscisse,p->ordonner,x, y,bonne_rotation(p));
        if(trouver == 1 ){
            piece_select_crea = p ;
            if (piece_select_crea->select == 0) {
                piece_select_crea = cloner_piece(p);
                piece_select_crea->select = 1;
                add_piece(pieces_reserve_crea, piece_select_crea) ;
                pieces_reserve_crea->nb_piece -= 1 ;
            }
        }
        p = p->suivant;
    }
    p = pieces_jouees_crea->plateau->suivant;
    while (p && trouver != 1) {
        trouver = selection_carre_crea(p->abscisse,p->ordonner,x, y,bonne_rotation(p));
        if(trouver == 1 ){
            enlever_piece_plateau(p) ;
            remise_en_jeu(pieces_reserve_crea,p,pieces_jouees_crea);
            pieces_reserve_crea->nb_piece -= 1 ;
            piece_select_crea = p;
            if (piece_select_crea->select == 0) {
                piece_select_crea->select = 1;
            }
        }
        p = p->suivant;
    }
    if (trouver == 0) {
        piece_select_crea = NULL;
    }
}

int ordo_sur_plateau_crea()
{
    int res = ((int)((piece_select_crea->ordonner - pieces_jouees_crea->plateau->ordonner)/taille_carre_crea))*taille_carre_crea + pieces_jouees_crea->plateau->ordonner;
    if ( ( res == pieces_jouees_crea->plateau->ordonner) && (piece_select_crea->ordonner < pieces_jouees_crea->plateau->ordonner) ) {
        res -= taille_carre_crea ;
    } else if (res < pieces_jouees_crea->plateau->ordonner) {
        res -= taille_carre_crea ;
    }
    return res ;
}

int absci_sur_plateau_crea()
{
    int res = ((int)((piece_select_crea->abscisse - pieces_jouees_crea->plateau->abscisse)/taille_carre_crea))*taille_carre_crea + pieces_jouees_crea->plateau->abscisse;
    if ( ( res == pieces_jouees_crea->plateau->abscisse) && (piece_select_crea->abscisse < pieces_jouees_crea->plateau->abscisse) ) {
        res -= taille_carre_crea ;
    } else if (res < pieces_jouees_crea->plateau->abscisse ) {
        res -= taille_carre_crea ;
    }
    return res ;
}

int curseur_sur_plateau_crea(int x,int y)
{
    list_carre * lc = bonne_rotation(piece_select_crea);
    int larg = (lc->largeur - 1) * taille_carre_crea ;
    int haut = (lc->hauteur - 1) * taille_carre_crea ;
    if( (x >= A_PLATEAU - larg ) && (x <= (A_PLATEAU + L_PLATEAU) ) ){
        if( (y >= O_PLATEAU - haut) && (y <= (O_PLATEAU + H_PLATEAU) ) ){
            return 1;
        }
    }
    return 0;
}

int pouvoir_lacher_crea()
{
    if (piece_select_crea->abscisse < L_LISTE) {
        return 0;
    }
    if (piece_select_crea->ordonner < H_BANDEAU) {
        if (piece_select_crea->abscisse >= A_BOUTONR1)
        return 0;
    }
    return 1;
}

int est_adjacent_pieces_jouees(int adjacent, int abscisse, int ordonner, carre * carre_jouer, carre * carre_temoin, piece * piece_temoin)
{
    if(abscisse + (carre_jouer->abscisse + 1) * taille_carre_crea == carre_temoin->abscisse * taille_carre_crea + piece_temoin->abscisse){
        if(ordonner + carre_jouer->ordonner * taille_carre_crea == carre_temoin->ordonner * taille_carre_crea + piece_temoin->ordonner){
            adjacent += 1;
        }
    }
    if(abscisse + (carre_jouer->abscisse - 1) * taille_carre_crea == carre_temoin->abscisse * taille_carre_crea + piece_temoin->abscisse){
        if(ordonner + carre_jouer->ordonner * taille_carre_crea == carre_temoin->ordonner * taille_carre_crea + piece_temoin->ordonner){
            adjacent += 1;
        }
    }
    if(abscisse + carre_jouer->abscisse * taille_carre_crea == carre_temoin->abscisse * taille_carre_crea + piece_temoin->abscisse){
        if(ordonner + (carre_jouer->ordonner + 1) * taille_carre_crea == carre_temoin->ordonner * taille_carre_crea + piece_temoin->ordonner){
            adjacent += 1;
        }
    }
    if(abscisse + carre_jouer->abscisse * taille_carre_crea == carre_temoin->abscisse * taille_carre_crea + piece_temoin->abscisse){
        if(ordonner + (carre_jouer->ordonner - 1) * taille_carre_crea == carre_temoin->ordonner * taille_carre_crea + piece_temoin->ordonner){
            adjacent += 1;
        }
    }
    return adjacent;
}

int accepter_sur_plateau_crea()
{
    int adjacent;
    int abscisse = absci_sur_plateau_crea();
    int ordonner = ordo_sur_plateau_crea();
    list_carre * carres_jouer = bonne_rotation(piece_select_crea);
    piece * piece_temoin = pieces_jouees_crea->plateau->suivant;
    if (piece_temoin == NULL) {
        return 1;
    }
    adjacent = 0 ;
    while(piece_temoin ){
        carre * carre_temoin = bonne_rotation(piece_temoin)->premier;
        while(carre_temoin){
            carre * carre_jouer = carres_jouer->premier;
                while(carre_jouer){
                    if(abscisse + carre_jouer->abscisse *taille_carre_crea == carre_temoin->abscisse * taille_carre_crea + piece_temoin->abscisse){
                        if(ordonner + carre_jouer->ordonner *taille_carre_crea == carre_temoin->ordonner * taille_carre_crea + piece_temoin->ordonner){
                                return 0;
                        }
                    }
                    adjacent = est_adjacent_pieces_jouees(adjacent,abscisse, ordonner, carre_jouer, carre_temoin, piece_temoin) ;
                    carre_jouer = carre_jouer->suivant;
                }
            carre_temoin = carre_temoin->suivant;
        }
        piece_temoin = piece_temoin->suivant;
    }
    if (adjacent == 0) {
        return 0;
    }
    return 1;
}

void remise_a_zero_coordonnees_carres(int abscisse_neg_max, int ordonner_neg_max)
{
    list_carre * carres_plateau = pieces_jouees_crea->plateau->rotation1 ;
    carre * c = carres_plateau->premier ;
    while (c) {
        c->abscisse += -abscisse_neg_max ;
        c->ordonner += -ordonner_neg_max;
        if (c->abscisse >= carres_plateau->largeur) {
            carres_plateau->largeur = c->abscisse + 1;
        }
        if (c->ordonner >= carres_plateau->hauteur) {
            carres_plateau->hauteur = c->ordonner + 1 ;
        }
        c = c->suivant;
    }
}

void decaler_pieces_jouees(int insert_up, int insert_left)
{
    piece * plateau = pieces_jouees_crea->plateau ;
    piece * piece_parcours = plateau->suivant ;
    int decal_absci = plateau->abscisse ;
    int decal_ordo = plateau->ordonner ;
    plateau->abscisse = A_PLATEAU + (int) ((L_PLATEAU - (taille_carre_crea * plateau->rotation1->largeur)) / 2) ;
    plateau->ordonner = O_PLATEAU + (int) ((H_PLATEAU - (taille_carre_crea * plateau->rotation1->hauteur)) / 2) ;
    decal_absci = decal_absci - plateau->abscisse ;
   if (insert_left > 0) {
        decal_absci = - decal_absci - 1;
    }
    decal_ordo = decal_ordo - plateau->ordonner ;
    if (insert_up > 0) {
        decal_ordo = - decal_ordo - 1;
    }
    while (piece_parcours) {
        piece_parcours->abscisse -= decal_absci ;
        if ((piece_parcours-> abscisse - plateau->abscisse) % taille_carre_crea != 0) {
                piece_parcours-> abscisse -= (piece_parcours-> abscisse - plateau->abscisse) % taille_carre_crea ;
        }
        piece_parcours->ordonner -= decal_ordo ;
        if ((piece_parcours-> ordonner - plateau->ordonner) % taille_carre_crea != 0) {
                piece_parcours-> ordonner -= (piece_parcours-> ordonner - plateau->ordonner) % taille_carre_crea ;
        }
        piece_parcours = piece_parcours->suivant ;
    }
}

void redimensionner_pieces_jouees(int last_t, int new_t)
{
    int abscisse = pieces_jouees_crea->plateau->abscisse, ordonner = pieces_jouees_crea->plateau->ordonner;
    piece * piece_parcours = pieces_jouees_crea->plateau->suivant ;
    while (piece_parcours) {
        piece_parcours->abscisse = (new_t * (piece_parcours->abscisse - abscisse) / last_t) + abscisse ;
        piece_parcours->ordonner = (new_t * (piece_parcours->ordonner - ordonner) / last_t) + ordonner ;
        piece_parcours = piece_parcours->suivant ;
    }
}

void modification_dimensions_plateau (int * remove_up, int * remove_left)
{
    int abs_min , abs_max = 0, ord_min, ord_max = 0;
    list_carre * plateau = pieces_jouees_crea->plateau->rotation1 ;
    carre * c = plateau->premier ;
    if (c == NULL) {
        plateau->hauteur = 0 ;
        plateau->largeur = 0 ;
    } else {
        abs_min = c->abscisse ;
        ord_min = c->ordonner ;
        while (c) {
                if (c->abscisse < abs_min) {
                    abs_min = c->abscisse ;
                }
                if (c->abscisse > abs_max) {
                    abs_max = c->abscisse ;
                }
                if (c->ordonner < ord_min) {
                    ord_min = c->ordonner ;
                }
                if (c->ordonner > ord_max) {
                    ord_max = c->ordonner ;
                }
                c = c->suivant ;
        }
        plateau->largeur = abs_max + 1;
        plateau->hauteur = ord_max + 1;
        if (abs_min != 0 || ord_min != 0) {
            c = plateau->premier ;
            plateau->largeur -= abs_min;
            plateau->hauteur -= ord_min ;
            if (abs_min != 0) {
                *remove_left = 1;
            }
            if (ord_min != 0) {
                *remove_up = 1;
            }
            while(c) {
                c->abscisse -= abs_min ;
                c->ordonner -= ord_min ;
                c = c->suivant ;
            }
        }
    }
}

void ajouter_piece_plateau(piece * p)
{
    piece * plateau = pieces_jouees_crea->plateau;
    list_carre * carres_plateau = plateau->rotation1 ;
    int plateau_vide = 0;
    int decal_absci = (int)((p->abscisse - plateau->abscisse) / taille_carre_crea) ;
    int decal_ordo = (int)((p->ordonner - plateau->ordonner) / taille_carre_crea) ;
    int abscisse_neg_max = 0, ordonner_neg_max = 0 ;
    if (carres_plateau->premier == NULL) {
        plateau_vide = 1;
        if (p->abscisse > plateau->abscisse) {
            decal_absci = 0 ;
        }
        if (p->ordonner > plateau->ordonner) {
            decal_ordo = 0 ;
        }
    }
    carre * c = bonne_rotation(p)->premier ;
    while (c) {
        add_carre(carres_plateau, decal_absci + c->abscisse, decal_ordo + c->ordonner) ;
        if (decal_absci + c->abscisse < abscisse_neg_max) {
            abscisse_neg_max = decal_absci + c->abscisse ;
        }
        if (decal_ordo + c->ordonner < ordonner_neg_max) {
            ordonner_neg_max = decal_ordo + c->ordonner ;
        }
        c = c->suivant ;
    }
    if (plateau_vide == 1) {
        list_carre * p_rotation = bonne_rotation(p) ;
        carres_plateau->hauteur = p_rotation->hauteur ;
        carres_plateau->largeur = p_rotation->largeur ;
        plateau->abscisse = A_PLATEAU + (int) ((L_PLATEAU - (taille_carre_crea * plateau->rotation1->largeur)) / 2) ;
        plateau->ordonner = O_PLATEAU + (int) ((H_PLATEAU - (taille_carre_crea * plateau->rotation1->hauteur)) / 2) ;
        p->abscisse = plateau->abscisse ;
        p->ordonner = plateau->ordonner ;
        remise_a_zero_coordonnees_carres(abscisse_neg_max, ordonner_neg_max ) ;
    } else {
        remise_a_zero_coordonnees_carres(abscisse_neg_max, ordonner_neg_max) ;
        decaler_pieces_jouees(-ordonner_neg_max, - abscisse_neg_max);
        if ( (carres_plateau->hauteur + 2) * taille_carre_crea > H_PLATEAU) {
            int ancienne_taille = taille_carre_crea ;
            taille_carre_crea = (H_PLATEAU / (carres_plateau->hauteur + 1 ) ) ;
            redimensionner_pieces_jouees(ancienne_taille, taille_carre_crea);
            decaler_pieces_jouees(0, 0);
        }
        if ( (carres_plateau->largeur + 2 ) * taille_carre_crea > L_PLATEAU) {
            int ancienne_taille = taille_carre_crea ;
            taille_carre_crea = (L_PLATEAU / (carres_plateau->largeur + 1 )) ;
            redimensionner_pieces_jouees(ancienne_taille, taille_carre_crea);
            decaler_pieces_jouees(0, 0);
        }
    }
}

void enlever_piece_plateau(piece * p)
{
    piece * plateau = pieces_jouees_crea->plateau;
    list_carre * carres_plateau = plateau->rotation1 ;
    int decal_absci = (int)((p->abscisse - plateau->abscisse) / taille_carre_crea) ;
    int decal_ordo = (int)((p->ordonner - plateau->ordonner) / taille_carre_crea) ;
    int remove_up = 0, remove_left = 0;
    carre * c = bonne_rotation(p)->premier, * carre_temoin ;
    while (c) {
        carre_temoin = carres_plateau->premier ;
        while (carre_temoin) {
            if ((carre_temoin->abscisse == decal_absci + c->abscisse) && (carre_temoin->ordonner == decal_ordo + c->ordonner) ) {
                carre * temp = carre_temoin->suivant ;
                supp_carre(carres_plateau, carre_temoin) ;
                carre_temoin = temp ;
            } else {
                carre_temoin = carre_temoin->suivant ;
            }
        }
        c = c->suivant ;
    }
    modification_dimensions_plateau(&remove_up, &remove_left) ;
    decaler_pieces_jouees(remove_up, remove_left);
}

void eclaire_case_crea()
{
    carre *c = bonne_rotation(piece_select_crea)->premier;
    while(c){
        add_carre(A_eclair_crea,c->abscisse,c->ordonner);
        c = c->suivant;
    }
}

void HandleEventInCrea(SDL_Event event, SDL_Surface * screen)
{
    switch (event.type) {
    case SDL_KEYDOWN:
        switch(event.key.keysym.sym) {

        case SDLK_ESCAPE:
            fin_crea = -1;
            break;

        default:
            break;

        break;
        }

    case SDL_MOUSEMOTION:
        if (piece_select_crea) {
            list_carre * c = bonne_rotation(piece_select_crea) ;
            if (event.motion.x < L_ECRAN - c->largeur * taille_carre_crea) {
                piece_select_crea->abscisse = event.motion.x;
            }
            if (event.motion.y < H_ECRAN - c->hauteur * taille_carre_crea) {
                piece_select_crea->ordonner = event.motion.y;
            }
            if(curseur_sur_plateau_crea(event.motion.x,event.motion.y)){
                if (accepter_sur_plateau_crea() == 1) {
                    eclaire_case_crea();
                }
            }
        }
        break;

    case SDL_MOUSEBUTTONDOWN:
        switch (event.button.button) {

        case SDL_BUTTON_LEFT:
                if (piece_select_crea) {
                    if(curseur_sur_plateau_crea(event.motion.x,event.motion.y)) {
                            if(accepter_sur_plateau_crea() == 1) {
                                piece_select_crea->abscisse = absci_sur_plateau_crea();
                                piece_select_crea->ordonner = ordo_sur_plateau_crea();
                                piece_select_crea->select = 0;
                                jouer_piece(pieces_reserve_crea,piece_select_crea,pieces_jouees_crea);
                                ajouter_piece_plateau(piece_select_crea) ;
                                piece_select_crea = NULL;
                            }
                    } else if(pouvoir_lacher_crea() == 1) {
                            piece_select_crea = NULL;
                    }
                } else {
                    selection_creation(event.motion.x, event.motion.y, screen);
                }
            break;

        case SDL_BUTTON_RIGHT:
            if (piece_select_crea) {
                sup_piece_dans_list(pieces_reserve_crea, piece_select_crea) ;
                piece_select_crea = NULL;
            }
            break;

        case SDL_BUTTON_MIDDLE:
            if (piece_select_crea) {
                piece_select_crea->rotation = - piece_select_crea->rotation;
                if(curseur_sur_plateau_crea(event.motion.x,event.motion.y) == 1) {
                    if (accepter_sur_plateau_crea() == 1) {
                    eclaire_case_crea();
                    }
                }
            }
            break;

        case SDL_BUTTON_WHEELUP:
            if (piece_select_crea) {
                piece_select_crea->rotation += 1;
                if (piece_select_crea->rotation > 4) {
                    piece_select_crea->rotation = 1;
                }
                if (piece_select_crea->rotation == 0) {
                    piece_select_crea->rotation = -4;
                }
                if(curseur_sur_plateau_crea(event.motion.x,event.motion.y) == 1){
                    if (accepter_sur_plateau_crea() == 1) {
                        eclaire_case_crea();
                    }
                }
            }
            break;

        case SDL_BUTTON_WHEELDOWN:
            if (piece_select_crea) {
                piece_select_crea->rotation -= 1;
                if (piece_select_crea->rotation == 0) {
                    piece_select_crea->rotation = 4;
                }
                if (piece_select_crea->rotation < -4) {
                    piece_select_crea->rotation = -1;
                }
                if(curseur_sur_plateau_crea(event.motion.x,event.motion.y) == 1){
                    if (accepter_sur_plateau_crea() == 1) {
                        eclaire_case_crea();
                    }
                }
            }
            break;

        break;
        }
    }
}

void CreerPentomino(SDL_Surface * screen, char * chemin_niveau)
{
      SDL_Event event ;
      screen_crea = screen ;
      SDL_Surface *temp = SDL_LoadBMP("Yoshi_Game.bmp");
      backgroundc = SDL_DisplayFormat(temp);
      SDL_FreeSurface(temp) ;
      temp = SDL_LoadBMP("Oeuf_Rouge.bmp");
      b1c = SDL_DisplayFormat(temp) ;
      SDL_FreeSurface(temp) ;
      temp = SDL_LoadBMP("Oeuf_Rouge_i.bmp");
      b2c = SDL_DisplayFormat(temp) ;
      SDL_FreeSurface(temp) ;
      temp = SDL_LoadBMP("Bouton_Creation.bmp");
      SDL_Surface * bsc = SDL_DisplayFormat(temp) ;
      SDL_FreeSurface(temp) ;
      SDL_Rect * pos_bsc = (SDL_Rect *) malloc(sizeof(SDL_Rect));
      pos_bsc->x = 860;
      pos_bsc->y = 0;
      SDL_BlitSurface(bsc, NULL, backgroundc, pos_bsc) ;
      SDL_UpdateRect(backgroundc, 0, 0, 0, 0) ;
      free(pos_bsc) ;
      free(bsc) ;
      pos_bgc = (SDL_Rect *) malloc(sizeof(SDL_Rect));
      pos_bgc->x = 0;
      pos_bgc->y = 0;
      pos_b1c = (SDL_Rect *) malloc(sizeof(SDL_Rect));
      pos_b1c->x = A_BOUTON1;
      pos_b1c->y = O_BOUTON1;
      pos_b2c = (SDL_Rect *) malloc(sizeof(SDL_Rect));
      pos_b2c->x = A_BOUTON2;
      pos_b2c->y = O_BOUTON2;

      A_eclair_crea = creat_list_carre();
      carre_plateau_vide_crea = creat_list_carre() ;
      pieces_reserve_crea = lecture(&taille_carre_crea, carre_plateau_vide_crea, chemin_niveau) ;
      pieces_jouees_crea = creat_list_piece() ;
      jouer_piece(pieces_reserve_crea, pieces_reserve_crea->plateau, pieces_jouees_crea) ;
      pieces_jouees_crea->plateau->abscisse = 750 ;
      pieces_jouees_crea->plateau->ordonner = 400 ;
      pieces_jouees_crea->plateau->rotation1->hauteur = 0 ;
      pieces_jouees_crea->plateau->rotation1->largeur = 0 ;
      supp_carre(pieces_jouees_crea->plateau->rotation1, pieces_jouees_crea->plateau->rotation1->premier) ;

      int a_a_eclair;
      int o_a_eclair;
      fin_crea = 0;

      while (fin_crea == 0){
        SDL_BlitSurface(backgroundc, NULL, screen, pos_bgc) ;
        a_a_eclair = 0;
        o_a_eclair = 0;
        if(piece_select_crea){
            a_a_eclair = absci_sur_plateau_crea();
            o_a_eclair = ordo_sur_plateau_crea();
        }
        dessiner_ttes_pieces(screen, pieces_reserve_crea, pieces_jouees_crea, taille_carre_crea, decal_list_piece_2, A_eclair_crea, a_a_eclair, o_a_eclair) ;
        if(piece_select_crea){
            supp_list_carre(A_eclair_crea);
            A_eclair_crea =creat_list_carre();
        }
        SDL_WaitEvent(&event) ;
        HandleEventInCrea(event, screen) ;
        SDL_UpdateRect(screen, 0, 0, 0, 0) ;
      }
      if (fin_crea == 1) {
            char * perlimpimpim = lancer_saisie(screen, chemin_niveau) ;
            ecrire_fichier(pieces_jouees_crea, perlimpimpim) ;
      }
      sup_list_piece(pieces_reserve_crea) ;
      sup_list_piece(pieces_jouees_crea) ;
      supp_list_carre(A_eclair_crea) ;
      SDL_FreeSurface(backgroundc) ;
      SDL_FreeSurface(b1c) ;
      SDL_FreeSurface(b2c) ;
}

